Kotlin Functions(科特林函数/方法)
目录：
1、Function Declarations（函数的定义）
2、Function Usage（函数的用法）
3、Parameters（参数）
4、Default Arguments（默认参数）
5、Named Arguments（命名参数）
6、Unit-returning functions（函数返回类型为:Unit）
7、Single-Expression functions（单个表达式的函数）
8、Variable number of arguments（Varargs）(可变数量参数)
9、Infix notation（中缀表示法）
10、Function Scope（函数范围）
11、Generic Functions（通用函数/泛型函数）
12、Tail recursive functions（尾递归函数）
1. Function Declarations（函数/方法的定义）
使用fun关键字进行定义函数
fun double(x: Int): Int {
return 2 * x
}2. Function Usage（函数的使用/调用）
调用函数使用传统方法
val result = double(2)使用点符号调用
Sample().foo()3. Parameters（参数）
函数参数的定义格式：name:Type，以“，”分隔参数
fun double(x: Int, y: Int): Int {
return 2 * (x + y)
}4. Default Arguments（参数的默认值）
函数的参数可以有一个默认的值，
fun double(x: Int = 0, y: Int = 0): Int {
return 2 * (x + y)
}覆盖方法始终使用与基本方法相同的默认参数值。使用默认参数值覆盖方法时，忽略参数默认值
open class A {
open fun foo(i: Int = 10) {
}
}
class B : A() {
//// no default value allowed
override fun foo(i: Int) {
super.foo(i)
}
}调用函数，使用函数的默认参数值
fun defaultParam(a: Int = 0, b: Int): Int {
return a + b;
}
//使用defaultParam(b = 2)，等同于defaultParam(a = 0,b = 2)
val defaultParamResult = defaultParam(b = 2)如果默认参数之后的最后一个参数是lambda，他可以作为命名参数传递，也可以在括号之外传递
fun fooFunction(bar: Int = 1, baz: Int = 1, lamb: () -> Int): Int {
println("foo: lambda result=${lamb()}")
return lamb()
} //括号之外传递
val lambdaParamOutResult = fooFunction {
""
1
}
//括号之内传递
val lambdaParamInResult = fooFunction(lamb = {
""
1
})
//括号之内传递，并且全参数赋值
val lambdaParamFullResult = fooFunction(1, 2, lamb = {
""
1
})5. 命名参数->使代码更具可读性
调用函数时可以命名函数参数。当函数具有大量参数或默认参数时，这非常方便。
如下函数：
fun reformat(str: String,
normalizeCase: Boolean = true,
upperCaseFirstLetter: Boolean = true,
divideByCamelHumps: Boolean = false,
wordSeparator: Char = ' ') {
}使用默认参数调用：
val str = "";
reformat(str)使用非默认参数调用：
val str = "";
reformat(str, true, true, false, '_')使用命名参数调用->使代码更具可读性：
val str = "";
reformat(str, normalizeCase = true, upperCaseFirstLetter = true, divideByCamelHumps = false, wordSeparator = '_')使用命名参数调用->不需要所有的参数
val str = "";
reformat(str, wordSeparator = '_')当使用位置参数和命名参数调用函数时，所有位置参数应放在第一个命名参数之前。例如，f(1,y=1)允许，f(x=1,2)不允许
fun reformatTwo(
str: String = "",
normalizeCase: Boolean,
upperCaseFirstLetter: Boolean = true,
divideByCamelHumps: Boolean = false,
wordSeparator: Char = ' '
) {
}不允许此调用方式
//is not allowed.
reformatTwo(str = "", false)
//is allowed
reformatTwo(str = "", normalizeCase = false)允许此调用方式
//is allowed
reformatTwo(str = "", normalizeCase = false)6. Unit-returning functions
如果一个函数没有返回值，那么他的返回值类型是Unit
fun nullReturnType(): Unit {
}Unit可省略
fun nullReturnType() {
}7. Single-Expression functions
当函数返回单个表达式时，可以省略花括号，并在‘=’符号后指定‘函数体’
fun singleExpression(a: Int, b: Int): Int = a + b;显示声明的返回类型是可选的/可省略的
fun singleExpression(a: Int, b: Int) = a + b;8. Variable number of arguments(varargs)
可变数量的参数
fun varargParameter(vararg parameters: String): Int {
return parameters.size;
}
varargParameter("one", "two", "three");9. Infix notation（中缀表示法）
中缀表示法：省略点和括号
- 必须是成员函数或扩展函数
- 必须有一个参数
- 参数不能接收可变数量的参数，不能有默认值
infix fun Int.complete(num: Int) {
}
//正常的调用函数
1.complete(1)
//使用"中缀表达法"调用函数
1 complete 110. Function Scope
- Local Functions（函数内的函数）
- Member Functions（成员函数）
Local Functions（定义在函数内的函数）
fun function(name: String) {
fun localFunction(name: String): String {
return "local->$name"
}
val result = localFunction(name)
}Member Functions（定义在类/对象中的函数）
class Sample(){
fun foo(){}
}11. Generic Functions（通用函数/泛型函数）
fun <T> singletonList(item: T): List<T> {
return listOf<T>(item)
}12. Tail recursive functions（尾递归函数）
Kotlin支持一种称为“尾递归”的函数式变成。这允许一些通常使用循环编写的算法改为使用尾递归函数编写，但没有溢出的风险。当一个函数用tailrec修饰符标记并满足所需的形式时，编译器会优化递归，而是留下一个快速有效的基于循环的版本：
tailrec修饰的尾递归的函数
/*
tailrec修饰符关键字：将函数标记为‘尾递归’
尾递归函数
*/
const val EPS = 10
tailrec fun findFixPoint(x: Double = 1.0): Double =
if (Math.abs((x - Math.cos(x))) < EPS) x else findFixPoint(Math.cos(x))等同于：
const val EPS = 10
fun findFixPoint(): Double {
var x = 1.0
while (true) {
val y = Math.cos(x)
if (Math.abs(x - y) < EPS) {
return x
}
x = Math.cos(x)
}
}未完待续。。。
